{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# HW5-Lab1 - 微调BERT预训练模型 - Math Word Problem"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. 数据集准备\n",
    "\n",
    "我们仍然使用 [Math23K](https://paperswithcode.com/dataset/math23k) 数据集。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "import math\n",
    "\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch import Tensor\n",
    "from torch.utils.data import Dataset\n",
    "\n",
    "DEVICE = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "# Set seed.\n",
    "seed = 42\n",
    "np.random.seed(seed)\n",
    "torch.manual_seed(seed)\n",
    "torch.cuda.manual_seed(seed)\n",
    "torch.backends.cudnn.deterministic = True\n",
    "torch.backends.cudnn.benchmark = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "训练集大小: 22162\n",
      "测试集大小: 1000\n",
      "问题 1: 甲数除以乙数的商是temp_a，如果甲数增加temp_b，则甲数是乙的temp_c倍．原来甲数=．\n",
      "方程 1: ['temp_b', '/', '(', 'temp_c', '-', 'temp_a', ')', '*', 'temp_a']\n",
      "--------------------\n",
      "问题 2: 客车和货车分别从A、B两站同时相向开出，temp_a小时后相遇．相遇后，两车仍按原速度前进，当它们相距temp_b千米时，货车行了全程的temp_c%，客车已行的路程与未行的路程比是temp_d：temp_e．求A、B两站间的路程．\n",
      "方程 2: ['temp_b', '/', '(', 'temp_c', '+', '(', '(', 'temp_d', ')', '/', '(', 'temp_d', '+', 'temp_e', ')', ')', '-', '1', ')']\n",
      "--------------------\n",
      "问题 3: 图书角有书temp_a本，第一天借出了temp_b，第二天又还回temp_c本，现在图书角有多少本书？\n",
      "方程 3: ['temp_a', '*', '(', '1', '-', 'temp_b', ')', '+', 'temp_c']\n",
      "--------------------\n"
     ]
    }
   ],
   "source": [
    "def read_math23k_data(path):\n",
    "    \"\"\"读取 Math23K 数据集。\"\"\"\n",
    "    with open(path, \"r\", encoding=\"utf-8\") as f:\n",
    "        data = json.load(f)\n",
    "    problems = [item[\"text\"].replace(\" \", \"\") for item in data]\n",
    "    equations = [item[\"target_template\"][2:] for item in data]  # 移除方程的 'x=' 前缀\n",
    "    return problems, equations\n",
    "\n",
    "\n",
    "# 加载训练集和测试集\n",
    "train_path, test_path = \"data/train.json\", \"data/test.json\"\n",
    "train_problems, train_equations = read_math23k_data(train_path)\n",
    "test_problems, test_equations = read_math23k_data(test_path)\n",
    "\n",
    "print(f\"训练集大小: {len(train_problems)}\")\n",
    "print(f\"测试集大小: {len(test_problems)}\")\n",
    "\n",
    "# 打印一些示例数据\n",
    "for i in range(3):\n",
    "    print(f\"问题 {i+1}: {train_problems[i]}\")\n",
    "    print(f\"方程 {i+1}: {train_equations[i]}\")\n",
    "    print(\"-\" * 20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. 数据预处理\n",
    "\n",
    "在将数据输入 BERT 模型之前，我们需要对数据进行预处理，这包括：\n",
    "- 不同于之前，我们这里使用 BERT 的 tokenizer 对 problems 进行编码\n",
    "- 对于 equations 的编码和之前一样\n",
    "\n",
    "### 2.1 使用 BERT Tokenizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([ 101, 4508, 3144, 7370,  809,  734, 3144, 4638, 1555, 3221, 8282, 9085,\n",
      "         142,  143, 8024, 1963, 3362, 4508, 3144, 1872, 1217, 8282, 9085,  142,\n",
      "         144, 8024, 1156, 4508, 3144, 3221,  734, 4638, 8282, 9085,  142,  145,\n",
      "         945, 8026, 1333, 3341, 4508, 3144,  134, 8026,  102,    0,    0,    0,\n",
      "           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0])\n",
      "[CLS] 甲 数 除 以 乙 数 的 商 是 temp _ a ， 如 果 甲 数 增 加 temp _ b ， 则 甲 数 是 乙 的 temp _ c 倍 ． 原 来 甲 数 = ． [SEP] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD]\n"
     ]
    }
   ],
   "source": [
    "from transformers import BertTokenizer\n",
    "\n",
    "# 使用 bert-base-chinese 预训练模型\n",
    "src_tokenizer = BertTokenizer.from_pretrained(\"bert-base-chinese\")\n",
    "\n",
    "\n",
    "def preprocess_src_sentence(sentence, tokenizer, max_len):\n",
    "    inputs = tokenizer(\n",
    "        sentence,\n",
    "        add_special_tokens=True,\n",
    "        return_tensors=\"pt\",\n",
    "        padding=\"max_length\",\n",
    "        truncation=True,\n",
    "        max_length=max_len,\n",
    "    )\n",
    "    return inputs[\"input_ids\"].squeeze()\n",
    "\n",
    "\n",
    "out = preprocess_src_sentence(train_problems[0], src_tokenizer, 60)\n",
    "print(out)\n",
    "print(src_tokenizer.decode(out))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这段代码展示了如何使用预训练的 bert-base-chinese 模型的 tokenizer 对问题进行编码。preprocess_src_sentence 函数接收一个句子、tokenizer 和最大长度作为输入，并将句子转换为 BERT 模型可以理解的数字表示。\n",
    "\n",
    "### 2.2 对 equations 进行编码"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Target Vocab Size: 30\n",
      "tensor([ 2,  5,  6,  7, 10, 11,  4,  8,  9,  4,  3,  1,  1,  1,  1,  1,  1,  1,\n",
      "         1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,\n",
      "         1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1])\n",
      "<bos> temp_b / ( temp_c - temp_a ) * temp_a <eos> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad>\n"
     ]
    }
   ],
   "source": [
    "from collections import Counter\n",
    "\n",
    "\n",
    "class Vocab:\n",
    "    def __init__(self, sentence_list, min_count=1):\n",
    "        self.token2idx = {\"<unk>\": 0, \"<pad>\": 1, \"<bos>\": 2, \"<eos>\": 3}\n",
    "        self.build_vocab(sentence_list, min_count)\n",
    "\n",
    "    def build_vocab(self, sentence_list, min_count):\n",
    "        token_counts = Counter([token for sentence in sentence_list for token in sentence])\n",
    "        sorted_tokens = [token for token, count in token_counts.items() if count >= min_count]\n",
    "        sorted_tokens.sort(key=lambda token: token_counts[token], reverse=True)\n",
    "        for token in sorted_tokens:\n",
    "            self.token2idx[token] = len(self.token2idx)\n",
    "        self.idx2token = {idx: token for token, idx in self.token2idx.items()}\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.idx2token)\n",
    "\n",
    "    def token_to_index(self, token):\n",
    "        return self.token2idx.get(token, self.token2idx[\"<unk>\"])\n",
    "\n",
    "    def index_to_token(self, index):\n",
    "        return self.idx2token.get(index, \"<unk>\")\n",
    "\n",
    "    def to_tokens(self, indices):\n",
    "        return [self.index_to_token(index) for index in indices]\n",
    "\n",
    "    def to_indices(self, tokens):\n",
    "        return [self.token_to_index(token) for token in tokens]\n",
    "\n",
    "    def __repr__(self):\n",
    "        return f\"Vocab(size={len(self)})\"\n",
    "\n",
    "    def __getitem__(self, tokens):\n",
    "        if not isinstance(tokens, (list, tuple)):\n",
    "            return self.token_to_index(tokens)\n",
    "        return [self.token_to_index(token) for token in tokens]\n",
    "\n",
    "\n",
    "def preprocess_tgt_sentence(sentence, vocab, max_len):\n",
    "    sentence = [\"<bos>\"] + sentence + [\"<eos>\"]\n",
    "    indices = vocab[sentence]\n",
    "    indices = torch.tensor(indices)\n",
    "    if len(indices) > max_len:\n",
    "        indices = indices[:max_len]\n",
    "    else:\n",
    "        pad_size = max_len - len(indices)\n",
    "        indices = F.pad(indices, (0, pad_size), value=vocab[\"<pad>\"])\n",
    "    return indices\n",
    "\n",
    "\n",
    "tgt_vocab = Vocab(train_equations + test_equations)\n",
    "print(f\"Target Vocab Size: {len(tgt_vocab)}\")\n",
    "\n",
    "out = preprocess_tgt_sentence(train_equations[0], tgt_vocab, 50)\n",
    "print(out)\n",
    "print(\" \".join(tgt_vocab.to_tokens(out.tolist())))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3 创建数据集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Math23kDataset(Dataset):\n",
    "    def __init__(self, problems, equations, src_tokenizer, tgt_vocab, src_max_len=120, tgt_max_len=50):\n",
    "        self.src_data = [preprocess_src_sentence(sentence, src_tokenizer, src_max_len) for sentence in problems]\n",
    "        self.tgt_data = [preprocess_tgt_sentence(sentence, tgt_vocab, tgt_max_len) for sentence in equations]\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.src_data)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        return self.src_data[idx], self.tgt_data[idx]\n",
    "\n",
    "\n",
    "# 创建数据集\n",
    "train_dataset = Math23kDataset(train_problems, train_equations, src_tokenizer, tgt_vocab)\n",
    "test_dataset = Math23kDataset(test_problems, test_equations, src_tokenizer, tgt_vocab)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. 构建模型\n",
    "\n",
    "这里我们定义一个 BertSeq2SeqTransformer 模型，它使用预训练的 BERT 模型作为编码器，并使用 Transformer 解码器生成公式，其中 BERT 模型的权重固定，不参与训练。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "import math\n",
    "\n",
    "\n",
    "class PositionalEncoding(nn.Module):\n",
    "    def __init__(self, emb_size: int, dropout: float, maxlen: int = 5000):\n",
    "        super(PositionalEncoding, self).__init__()\n",
    "        den = torch.exp(-torch.arange(0, emb_size, 2) * math.log(10000) / emb_size)\n",
    "        pos = torch.arange(0, maxlen).reshape(maxlen, 1)\n",
    "        pos_embedding = torch.zeros((maxlen, emb_size))\n",
    "        pos_embedding[:, 0::2] = torch.sin(pos * den)\n",
    "        pos_embedding[:, 1::2] = torch.cos(pos * den)\n",
    "\n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "        self.register_buffer(\"pos_embedding\", pos_embedding)\n",
    "\n",
    "    def forward(self, token_embedding: torch.Tensor):\n",
    "        return self.dropout(token_embedding + self.pos_embedding[: token_embedding.size(1), :])\n",
    "\n",
    "\n",
    "class TokenEmbedding(nn.Module):\n",
    "    def __init__(self, vocab_size: int, emb_size):\n",
    "        super(TokenEmbedding, self).__init__()\n",
    "        self.embedding = nn.Embedding(vocab_size, emb_size)\n",
    "        self.emb_size = emb_size\n",
    "\n",
    "    def forward(self, tokens: torch.Tensor):\n",
    "        return self.embedding(tokens.long()) * math.sqrt(self.emb_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from transformers import BertModel\n",
    "\n",
    "\n",
    "class BertSeq2SeqTransformer(nn.Module):\n",
    "    def __init__(\n",
    "        self, num_decoder_layers: int, emb_size, nhead, tgt_vocab_size, dim_feedforward: int = 512, dropout: float = 0.1\n",
    "    ):\n",
    "        super(BertSeq2SeqTransformer, self).__init__()\n",
    "\n",
    "        # 使用预训练的 BERT 模型作为编码器\n",
    "        self.bert = BertModel.from_pretrained(\"bert-base-chinese\")\n",
    "        # 冻结BERT模型的参数，使其在训练过程中不被更新\n",
    "        for param in self.bert.parameters():\n",
    "            param.requires_grad = False\n",
    "        self.bert_output_linear = nn.Linear(768, emb_size)\n",
    "\n",
    "        # 解码器部分\n",
    "        self.positional_encoding = PositionalEncoding(emb_size, dropout=dropout)\n",
    "        self.tgt_tok_emb = TokenEmbedding(tgt_vocab_size, emb_size)\n",
    "        decoder_layer = nn.TransformerDecoderLayer(\n",
    "            d_model=emb_size, nhead=nhead, dim_feedforward=dim_feedforward, dropout=dropout, batch_first=True\n",
    "        )\n",
    "        self.transformer_decoder = nn.TransformerDecoder(decoder_layer, num_layers=num_decoder_layers)\n",
    "        self.generator = nn.Linear(emb_size, tgt_vocab_size)\n",
    "\n",
    "    def forward(\n",
    "        self,\n",
    "        src: torch.Tensor,\n",
    "        trg: torch.Tensor,\n",
    "        src_mask: torch.Tensor,\n",
    "        tgt_mask: torch.Tensor,\n",
    "        src_padding_mask: torch.Tensor,\n",
    "        tgt_padding_mask: torch.Tensor,\n",
    "    ):\n",
    "        # TODO: 实现模型的前向传播\n",
    "        memory = self.encode(src, src_mask, src_padding_mask)\n",
    "        output = self.decode(trg, memory, tgt_mask)\n",
    "        return self.generator(output)\n",
    "\n",
    "    def encode(self, src: torch.Tensor, src_mask: torch.Tensor, src_key_padding_mask=None):\n",
    "        with torch.no_grad():\n",
    "            src_emb = self.bert(src, attention_mask=~src_key_padding_mask)[0]\n",
    "        src_emb = self.bert_output_linear(src_emb)\n",
    "        return src_emb\n",
    "\n",
    "    def decode(self, tgt: torch.Tensor, memory: torch.Tensor, tgt_mask: torch.Tensor):\n",
    "        return self.transformer_decoder(self.positional_encoding(self.tgt_tok_emb(tgt)), memory, tgt_mask)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. 训练模型\n",
    "\n",
    "### 4.1 定义训练函数和评估函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "SRC_PAD_IDX, TGT_PAD_IDX = 0, 1\n",
    "\n",
    "\n",
    "def create_mask(src, tgt):\n",
    "    src_seq_len = src.shape[1]\n",
    "    tgt_seq_len = tgt.shape[1]\n",
    "\n",
    "    src_mask = torch.zeros((src_seq_len, src_seq_len), dtype=torch.bool, device=DEVICE)\n",
    "    tgt_mask = torch.ones((tgt_seq_len, tgt_seq_len), dtype=torch.bool, device=DEVICE).triu_(diagonal=1)\n",
    "\n",
    "    src_padding_mask = src == SRC_PAD_IDX\n",
    "    tgt_padding_mask = tgt == TGT_PAD_IDX\n",
    "    return src_mask, tgt_mask, src_padding_mask, tgt_padding_mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_epoch(model, train_loader, optimizer, loss_fn):\n",
    "    model.train()\n",
    "    losses = 0\n",
    "    for src, tgt in train_loader:\n",
    "        src, tgt = src.to(DEVICE), tgt.to(DEVICE)\n",
    "        tgt_input = tgt[:, :-1]\n",
    "        src_mask, tgt_mask, src_padding_mask, tgt_padding_mask = create_mask(src, tgt_input)\n",
    "\n",
    "        logits = model(src, tgt_input, src_mask, tgt_mask, src_padding_mask, tgt_padding_mask)\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        tgt_out = tgt[:, 1:]\n",
    "        loss = loss_fn(logits.reshape(-1, logits.shape[-1]), tgt_out.reshape(-1))\n",
    "        loss.backward()\n",
    "\n",
    "        torch.nn.utils.clip_grad_norm_(model.parameters(), 1)\n",
    "\n",
    "        optimizer.step()\n",
    "        losses += loss.item()\n",
    "\n",
    "    return losses / len(train_loader)\n",
    "\n",
    "\n",
    "def evaluate(model, val_loader, loss_fn):\n",
    "    model.eval()\n",
    "    losses = 0\n",
    "    for src, tgt in val_loader:\n",
    "        src, tgt = src.to(DEVICE), tgt.to(DEVICE)\n",
    "        tgt_input = tgt[:, :-1]\n",
    "        src_mask, tgt_mask, src_padding_mask, tgt_padding_mask = create_mask(src, tgt_input)\n",
    "\n",
    "        logits = model(src, tgt_input, src_mask, tgt_mask, src_padding_mask, tgt_padding_mask)\n",
    "\n",
    "        tgt_out = tgt[:, 1:]\n",
    "        loss = loss_fn(logits.reshape(-1, logits.shape[-1]), tgt_out.reshape(-1))\n",
    "        losses += loss.item()\n",
    "\n",
    "    return losses / len(val_loader)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2 设置超参数和初始化模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total trainable params: 1.164446 M\n"
     ]
    }
   ],
   "source": [
    "TGT_VOCAB_SIZE = len(tgt_vocab)\n",
    "EMB_SIZE = 128\n",
    "NHEAD = 8  # 注意力头数\n",
    "FFN_HID_DIM = 512  # FeedForward隐藏层维度\n",
    "NUM_LAYERS = 4  # Transformer层数\n",
    "\n",
    "BATCH_SIZE = 64\n",
    "LEARNING_RATE = 0.0008\n",
    "DROP_OUT = 0.1\n",
    "\n",
    "model = BertSeq2SeqTransformer(NUM_LAYERS, EMB_SIZE, NHEAD, TGT_VOCAB_SIZE, FFN_HID_DIM, DROP_OUT)\n",
    "\n",
    "total_params = sum(p.numel() for p in model.parameters() if p.requires_grad)\n",
    "print(\"Total trainable params:\", total_params / 1e6, \"M\")\n",
    "\n",
    "model = model.to(DEVICE)\n",
    "\n",
    "criterion = nn.CrossEntropyLoss(ignore_index=tgt_vocab[\"<pad>\"])\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=LEARNING_RATE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.3 开始训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0, Train loss: 0.998, Val loss: 0.743, Epoch time = 62.231s\n",
      "Epoch: 1, Train loss: 0.699, Val loss: 0.614, Epoch time = 62.369s\n",
      "Epoch: 2, Train loss: 0.598, Val loss: 0.528, Epoch time = 62.368s\n",
      "Epoch: 3, Train loss: 0.536, Val loss: 0.502, Epoch time = 62.381s\n",
      "Epoch: 4, Train loss: 0.496, Val loss: 0.484, Epoch time = 62.393s\n",
      "Epoch: 5, Train loss: 0.464, Val loss: 0.446, Epoch time = 62.406s\n",
      "Epoch: 6, Train loss: 0.439, Val loss: 0.436, Epoch time = 62.408s\n",
      "Epoch: 7, Train loss: 0.422, Val loss: 0.417, Epoch time = 62.404s\n",
      "Epoch: 8, Train loss: 0.402, Val loss: 0.400, Epoch time = 62.408s\n",
      "Epoch: 9, Train loss: 0.391, Val loss: 0.400, Epoch time = 62.407s\n",
      "Epoch: 10, Train loss: 0.376, Val loss: 0.400, Epoch time = 62.408s\n",
      "Epoch: 11, Train loss: 0.363, Val loss: 0.379, Epoch time = 62.415s\n",
      "Epoch: 12, Train loss: 0.352, Val loss: 0.383, Epoch time = 62.425s\n",
      "Epoch: 13, Train loss: 0.344, Val loss: 0.384, Epoch time = 62.417s\n",
      "Epoch: 14, Train loss: 0.338, Val loss: 0.369, Epoch time = 62.420s\n",
      "Epoch: 15, Train loss: 0.328, Val loss: 0.360, Epoch time = 62.421s\n",
      "Epoch: 16, Train loss: 0.321, Val loss: 0.366, Epoch time = 62.428s\n",
      "Epoch: 17, Train loss: 0.316, Val loss: 0.356, Epoch time = 62.427s\n",
      "Epoch: 18, Train loss: 0.310, Val loss: 0.362, Epoch time = 62.426s\n",
      "Epoch: 19, Train loss: 0.301, Val loss: 0.364, Epoch time = 62.420s\n",
      "Epoch: 20, Train loss: 0.298, Val loss: 0.367, Epoch time = 62.426s\n",
      "Epoch: 21, Train loss: 0.294, Val loss: 0.357, Epoch time = 62.426s\n",
      "Epoch: 22, Train loss: 0.287, Val loss: 0.344, Epoch time = 62.414s\n",
      "Epoch: 23, Train loss: 0.283, Val loss: 0.354, Epoch time = 62.408s\n",
      "Epoch: 24, Train loss: 0.279, Val loss: 0.351, Epoch time = 62.418s\n",
      "Epoch: 25, Train loss: 0.275, Val loss: 0.338, Epoch time = 62.414s\n",
      "Epoch: 26, Train loss: 0.273, Val loss: 0.345, Epoch time = 62.415s\n",
      "Epoch: 27, Train loss: 0.269, Val loss: 0.347, Epoch time = 62.418s\n",
      "Epoch: 28, Train loss: 0.265, Val loss: 0.347, Epoch time = 62.404s\n",
      "Epoch: 29, Train loss: 0.262, Val loss: 0.348, Epoch time = 62.415s\n"
     ]
    }
   ],
   "source": [
    "from timeit import default_timer as timer\n",
    "\n",
    "from torch.utils.data import DataLoader\n",
    "\n",
    "NUM_EPOCHS = 30\n",
    "\n",
    "train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True)\n",
    "val_loader = DataLoader(test_dataset, batch_size=BATCH_SIZE)\n",
    "\n",
    "train_loss_list, valid_loss_list = [], []\n",
    "\n",
    "for epoch in range(NUM_EPOCHS):\n",
    "    start_time = timer()\n",
    "    train_loss = train_epoch(model, train_loader, optimizer, criterion)\n",
    "    val_loss = evaluate(model, val_loader, criterion)\n",
    "    end_time = timer()\n",
    "    train_loss_list.append(train_loss)\n",
    "    valid_loss_list.append(val_loss)\n",
    "    print(\n",
    "        (\n",
    "            f\"Epoch: {epoch}, Train loss: {train_loss:.3f}, Val loss: {val_loss:.3f}, \"\n",
    "            f\"Epoch time = {(end_time - start_time):.3f}s\"\n",
    "        )\n",
    "    )\n",
    "\n",
    "# 保存模型\n",
    "torch.save(model.state_dict(), \"bert_model.pth\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x700 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 602,
       "width": 846
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%config InlineBackend.figure_format='retina'\n",
    "plt.figure(figsize=(10, 7))\n",
    "plt.plot(train_loss_list, color=\"blue\", linestyle=\"-\", label=\"train loss\")\n",
    "plt.plot(valid_loss_list, color=\"red\", linestyle=\"-\", label=\"valid loss\")\n",
    "plt.xlabel(\"Epochs\")\n",
    "plt.ylabel(\"Loss\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. 模型评估"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def equation_accuracy(preds, tgts):\n",
    "    correct = 0\n",
    "    for tgt, pred in zip(tgts, preds):\n",
    "        if tgt == pred:\n",
    "            correct += 1\n",
    "    return correct / len(tgts)\n",
    "\n",
    "\n",
    "@torch.no_grad()\n",
    "def greedy_decode(model, src, max_len, start_symbol):\n",
    "    src = src.to(DEVICE)\n",
    "    ys = torch.ones(1, 1).fill_(start_symbol).type(torch.long).to(DEVICE)\n",
    "    src_mask, tgt_mask, src_padding_mask, _ = create_mask(src, ys)\n",
    "\n",
    "    memory = model.encode(src, src_mask, src_padding_mask)\n",
    "\n",
    "    for i in range(max_len - 1):\n",
    "        tgt_mask = torch.ones((ys.shape[1], ys.shape[1]), dtype=torch.bool, device=DEVICE).triu_(diagonal=1)\n",
    "\n",
    "        out = model.decode(ys, memory, tgt_mask)\n",
    "\n",
    "        prob = model.generator(out[:, -1])\n",
    "        _, next_word = torch.max(prob, dim=1)\n",
    "        next_word = next_word.item()\n",
    "\n",
    "        ys = torch.cat([ys, torch.ones(1, 1).fill_(next_word).type(torch.long).to(DEVICE)], dim=1)\n",
    "        if next_word == tgt_vocab[\"<eos>\"]:\n",
    "            break\n",
    "    return ys\n",
    "\n",
    "\n",
    "@torch.no_grad()\n",
    "def inference(model, problem):\n",
    "    model.eval()\n",
    "    src = preprocess_src_sentence(problem, src_tokenizer, 120)\n",
    "    src = src.unsqueeze(0)\n",
    "    tgt_tokens = greedy_decode(model, src, max_len=50, start_symbol=tgt_vocab[\"<bos>\"]).flatten()\n",
    "    return \"\".join(tgt_vocab.to_tokens(tgt_tokens.tolist())).replace(\"<bos>\", \"\").replace(\"<eos>\", \"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "问题 1: 在一正方形花池的四周栽了temp_a棵柳树，每两棵柳树之间的间隔是temp_b米，这个正方形的周长=多少米？\n",
      "真实方程: temp_a*temp_b\n",
      "预测方程: temp_b*(temp_a-1)\n",
      "--------------------\n",
      "问题 2: 张明有temp_a元钱，买书用去temp_b%，买文具的钱是买书的temp_c%．买文具用去多少元？\n",
      "真实方程: temp_a*temp_b*temp_c\n",
      "预测方程: temp_a*temp_b/temp_c\n",
      "--------------------\n",
      "问题 3: 一个工厂要生产temp_a个零件，前temp_b天生产了temp_c个，剩下的要在temp_d天内完成，平均每天生产多少个？\n",
      "真实方程: (temp_a-temp_c)/temp_d\n",
      "预测方程: (temp_a-temp_c)/temp_d\n",
      "--------------------\n",
      "问题 4: 一本字典定价temp_a元，temp_b出售后还赚temp_c%，这本字典进价=多少元．\n",
      "真实方程: temp_a*temp_b/(1+temp_c)\n",
      "预测方程: temp_a*temp_b/(1+temp_c)\n",
      "--------------------\n",
      "问题 5: 修一段长temp_a米的路，前temp_b小时共修了temp_c米，剩下的每小时修temp_d米，还要几小时才能修完？\n",
      "真实方程: (temp_a-temp_c)/temp_d\n",
      "预测方程: (temp_a-temp_c)/temp_d\n",
      "--------------------\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    problem, equation = test_problems[i], test_equations[i]\n",
    "    print(f\"问题 {i+1}: {problem}\")\n",
    "    print(f\"真实方程: {''.join(equation)}\")\n",
    "    print(f\"预测方程: {inference(model, problem)}\")\n",
    "    print(\"-\" * 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1000/1000 [00:13<00:00, 75.89it/s]\n"
     ]
    }
   ],
   "source": [
    "from tqdm import tqdm\n",
    "\n",
    "test_loader = DataLoader(test_dataset, batch_size=1)\n",
    "preds, tgts = [], []\n",
    "for src, tgt in tqdm(test_loader):\n",
    "    pred = greedy_decode(model, src, max_len=50, start_symbol=tgt_vocab[\"<bos>\"]).flatten()\n",
    "    pred = tgt_vocab.to_tokens(pred.tolist())\n",
    "    preds.append(\"\".join(pred).replace(\"<bos>\", \"\").replace(\"<eos>\", \"\").replace(\"<pad>\", \"\"))\n",
    "    tgts.append(\n",
    "        \"\".join(tgt_vocab.to_tokens(tgt[0].tolist())).replace(\"<bos>\", \"\").replace(\"<eos>\", \"\").replace(\"<pad>\", \"\")\n",
    "    )\n",
    "acc = equation_accuracy(preds, tgts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "方程准确率: 0.571\n"
     ]
    }
   ],
   "source": [
    "print(f\"方程准确率: {acc:.3f}\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "dl",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
